/*******************************************************************************
* Copyright (c) 2000, 2012 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.swt.widgets;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Pane;
import javafx.scene.layout.VBox;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.internal.GridPaneLayout;
import org.eclipse.swt.internal.PaneLayout;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridLayout;
/**
* Instances of this class are controls which are capable of containing other
* controls.
* <dl>
* <dt><b>Styles:</b></dt>
* <dd>NO_BACKGROUND, NO_FOCUS, NO_MERGE_PAINTS, NO_REDRAW_RESIZE,
* NO_RADIO_GROUP, EMBEDDED, DOUBLE_BUFFERED</dd>
* <dt><b>Events:</b></dt>
* <dd>(none)</dd>
* </dl>
* <p>
* Note: The <code>NO_BACKGROUND</code>, <code>NO_FOCUS</code>,
* <code>NO_MERGE_PAINTS</code>, and <code>NO_REDRAW_RESIZE</code> styles are
* intended for use with <code>Canvas</code>. They can be used with
* <code>Composite</code> if you are drawing your own, but their behavior is
* undefined if they are used with subclasses of <code>Composite</code> other
* than <code>Canvas</code>.
* </p>
* <p>
* Note: The <code>CENTER</code> style, although undefined for composites, has
* the same value as <code>EMBEDDED</code> which is used to embed widgets from
* other widget toolkits into SWT. On some operating systems (GTK, Motif), this
* may cause the children of this composite to be obscured.
* </p>
* <p>
* This class may be subclassed by custom control implementors who are building
* controls that are constructed from aggregates of other controls.
* </p>
*
* @see Canvas
* @see <a href="http://www.eclipse.org/swt/snippets/#composite">Composite
* snippets</a>
* @see <a href="http://www.eclipse.org/swt/">Sample code and further
* information</a>
*/
public class Composite extends Scrollable {
Layout layout;
PaneLayout paneLayout;
Control[] children;
/**
* Constructs a new instance of this class given its parent and a style
* value describing its behavior and appearance.
* <p>
* The style value is either one of the style constants defined in class
* <code>SWT</code> which is applicable to instances of this class, or must
* be built by <em>bitwise OR</em>'ing together (that is, using the
* <code>int</code> "|" operator) two or more of those <code>SWT</code>
* style constants. The class description lists the style constants that are
* applicable to the class. Style bits are also inherited from superclasses.
* </p>
*
* @param parent
* a widget which will be the parent of the new instance (cannot
* be null)
* @param style
* the style of widget to construct
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the parent</li>
* </ul>
*
* @see SWT#NO_BACKGROUND
* @see SWT#NO_FOCUS
* @see SWT#NO_MERGE_PAINTS
* @see SWT#NO_REDRAW_RESIZE
* @see SWT#NO_RADIO_GROUP
* @see SWT#EMBEDDED
* @see SWT#DOUBLE_BUFFERED
* @see Widget#getStyle
*/
public Composite(Composite parent, int style) {
super(parent, style);
createNode();
}
@Override
void createNode() {
// Plain composites are just panes. They'll get created when the first child is added
// to give a chance for the layouts to get filled.
}
void convertLayout() {
if (layout != null) {
if (layout instanceof FillLayout) {
if (((FillLayout)layout).type == SWT.VERTICAL) {
paneLayout = new PaneLayout(new VBox());
} else {
paneLayout = new PaneLayout(new HBox());
}
return;
} else if (layout instanceof GridLayout) {
paneLayout = new GridPaneLayout(new GridPane(), (GridLayout)layout);
return;
}
}
paneLayout = new PaneLayout(new Pane());
}
void createPane() {
convertLayout();
setNode(paneLayout.getPane());
}
void addChild(Control child) {
if (paneLayout == null)
createPane();
paneLayout.addChild(child.node);
if (children == null) {
children = new Control[1];
children[0] = child;
} else {
Control[] c = new Control[children.length + 1];
System.arraycopy(children, 0, c, 0, children.length);
c[children.length] = child;
children = c;
}
}
void removeChild(Control child) {
if (paneLayout != null)
paneLayout.removeChild(child.node);
if (children != null)
for (int i = 0; i < children.length; ++i)
if (children[i] == child) {
Control[] c = new Control[children.length - 1];
System.arraycopy(children, 0, children, 0, i);
System.arraycopy(children, i + 1, c, i, children.length - i - 1);
break;
}
}
/**
* Clears any data that has been cached by a Layout for all widgets that are
* in the parent hierarchy of the changed control up to and including the
* receiver. If an ancestor does not have a layout, it is skipped.
*
* @param changed
* an array of controls that changed state and require a
* recalculation of size
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the changed array is null
* any of its controls are null or have been disposed</li>
* <li>ERROR_INVALID_PARENT - if any control in changed is
* not in the widget tree of the receiver</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public void changed(Control[] changed) {
// TODO
}
/**
* Fills the interior of the rectangle specified by the arguments, with the
* receiver's background.
*
* <p>
* The <code>offsetX</code> and <code>offsetY</code> are used to map from
* the <code>gc</code> origin to the origin of the parent image background.
* This is useful to ensure proper alignment of the image background.
* </p>
*
* @param gc
* the gc where the rectangle is to be filled
* @param x
* the x coordinate of the rectangle to be filled
* @param y
* the y coordinate of the rectangle to be filled
* @param width
* the width of the rectangle to be filled
* @param height
* the height of the rectangle to be filled
* @param offsetX
* the image background x offset
* @param offsetY
* the image background y offset
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_NULL_ARGUMENT - if the gc is null</li>
* <li>ERROR_INVALID_ARGUMENT - if the gc has been disposed</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*
* @since 3.6
*/
public void drawBackground(GC gc, int x, int y, int width, int height,
int offsetX, int offsetY) {
// TODO
}
/**
* Returns the receiver's background drawing mode. This will be one of the
* following constants defined in class <code>SWT</code>:
* <code>INHERIT_NONE</code>, <code>INHERIT_DEFAULT</code>,
* <code>INHERIT_FORCE</code>.
*
* @return the background mode
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*
* @see SWT
*
* @since 3.2
*/
public int getBackgroundMode() {
// TODO
return 0;
}
/**
* Returns a (possibly empty) array containing the receiver's children.
* Children are returned in the order that they are drawn. The topmost
* control appears at the beginning of the array. Subsequent controls draw
* beneath this control and appear later in the array.
* <p>
* Note: This is not the actual structure used by the receiver to maintain
* its list of children, so modifying the array will not affect the
* receiver.
* </p>
*
* @return an array of children
*
* @see Control#moveAbove
* @see Control#moveBelow
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*/
public Control[] getChildren() {
return children;
}
/**
* Returns layout which is associated with the receiver, or null if one has
* not been set.
*
* @return the receiver's layout or null
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*/
public Layout getLayout() {
// TODO
return null;
}
/**
* Returns <code>true</code> if the receiver has deferred the performing of
* layout, and <code>false</code> otherwise.
*
* @return the receiver's deferred layout state
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*
* @see #setLayoutDeferred(boolean)
* @see #isLayoutDeferred()
*
* @since 3.1
*/
public boolean getLayoutDeferred() {
// TODO
return false;
}
/**
* Gets the (possibly empty) tabbing order for the control.
*
* @return tabList the ordered list of controls representing the tab order
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*
* @see #setTabList
*/
public Control[] getTabList() {
// TODO
return null;
}
/**
* Returns <code>true</code> if the receiver or any ancestor up to and
* including the receiver's nearest ancestor shell has deferred the
* performing of layouts. Otherwise, <code>false</code> is returned.
*
* @return the receiver's deferred layout state
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*
* @see #setLayoutDeferred(boolean)
* @see #getLayoutDeferred()
*
* @since 3.1
*/
public boolean isLayoutDeferred() {
// TODO
return false;
}
/**
* If the receiver has a layout, asks the layout to <em>lay out</em> (that
* is, set the size and location of) the receiver's children. If the
* receiver does not have a layout, do nothing.
* <p>
* This is equivalent to calling <code>layout(true)</code>.
* </p>
* <p>
* Note: Layout is different from painting. If a child is moved or resized
* such that an area in the parent is exposed, then the parent will paint.
* If no child is affected, the parent will not paint.
* </p>
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*/
public void layout() {
// TODO
}
/**
* If the receiver has a layout, asks the layout to <em>lay out</em> (that
* is, set the size and location of) the receiver's children. If the
* argument is <code>true</code> the layout must not rely on any information
* it has cached about the immediate children. If it is <code>false</code>
* the layout may (potentially) optimize the work it is doing by assuming
* that none of the receiver's children has changed state since the last
* layout. If the receiver does not have a layout, do nothing.
* <p>
* If a child is resized as a result of a call to layout, the resize event
* will invoke the layout of the child. The layout will cascade down through
* all child widgets in the receiver's widget tree until a child is
* encountered that does not resize. Note that a layout due to a resize will
* not flush any cached information (same as <code>layout(false)</code>).
* </p>
* <p>
* Note: Layout is different from painting. If a child is moved or resized
* such that an area in the parent is exposed, then the parent will paint.
* If no child is affected, the parent will not paint.
* </p>
*
* @param changed
* <code>true</code> if the layout must flush its caches, and
* <code>false</code> otherwise
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*/
public void layout(boolean changed) {
// TODO
}
/**
* If the receiver has a layout, asks the layout to <em>lay out</em> (that
* is, set the size and location of) the receiver's children. If the changed
* argument is <code>true</code> the layout must not rely on any information
* it has cached about its children. If it is <code>false</code> the layout
* may (potentially) optimize the work it is doing by assuming that none of
* the receiver's children has changed state since the last layout. If the
* all argument is <code>true</code> the layout will cascade down through
* all child widgets in the receiver's widget tree, regardless of whether
* the child has changed size. The changed argument is applied to all
* layouts. If the all argument is <code>false</code>, the layout will
* <em>not</em> cascade down through all child widgets in the receiver's
* widget tree. However, if a child is resized as a result of a call to
* layout, the resize event will invoke the layout of the child. Note that a
* layout due to a resize will not flush any cached information (same as
* <code>layout(false)</code>). </p>
* <p>
* Note: Layout is different from painting. If a child is moved or resized
* such that an area in the parent is exposed, then the parent will paint.
* If no child is affected, the parent will not paint.
* </p>
*
* @param changed
* <code>true</code> if the layout must flush its caches, and
* <code>false</code> otherwise
* @param all
* <code>true</code> if all children in the receiver's widget
* tree should be laid out, and <code>false</code> otherwise
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public void layout(boolean changed, boolean all) {
// TODO
}
/**
* Forces a lay out (that is, sets the size and location) of all widgets
* that are in the parent hierarchy of the changed control up to and
* including the receiver. The layouts in the hierarchy must not rely on any
* information cached about the changed control or any of its ancestors. The
* layout may (potentially) optimize the work it is doing by assuming that
* none of the peers of the changed control have changed state since the
* last layout. If an ancestor does not have a layout, skip it.
* <p>
* Note: Layout is different from painting. If a child is moved or resized
* such that an area in the parent is exposed, then the parent will paint.
* If no child is affected, the parent will not paint.
* </p>
*
* @param changed
* a control that has had a state change which requires a
* recalculation of its size
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if the changed array is null
* any of its controls are null or have been disposed</li>
* <li>ERROR_INVALID_PARENT - if any control in changed is
* not in the widget tree of the receiver</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*
* @since 3.1
*/
public void layout(Control[] changed) {
// TODO
}
/**
* Forces a lay out (that is, sets the size and location) of all widgets
* that are in the parent hierarchy of the changed control up to and
* including the receiver.
* <p>
* The parameter <code>flags</code> may be a combination of:
* <dl>
* <dt><b>SWT.ALL</b></dt>
* <dd>all children in the receiver's widget tree should be laid out</dd>
* <dt><b>SWT.CHANGED</b></dt>
* <dd>the layout must flush its caches</dd>
* <dt><b>SWT.DEFER</b></dt>
* <dd>layout will be deferred</dd>
* </dl>
* </p>
* <p>
* When the <code>changed</code> array is specified, the flags
* <code>SWT.ALL</code> and <code>SWT.CHANGED</code> have no effect. In this
* case, the layouts in the hierarchy must not rely on any information
* cached about the changed control or any of its ancestors. The layout may
* (potentially) optimize the work it is doing by assuming that none of the
* peers of the changed control have changed state since the last layout. If
* an ancestor does not have a layout, skip it.
* </p>
* <p>
* When the <code>changed</code> array is not specified, the flag
* <code>SWT.ALL</code> indicates that the whole widget tree should be laid
* out. And the flag <code>SWT.CHANGED</code> indicates that the layouts
* should flush any cached information for all controls that are laid out.
* </p>
* <p>
* The <code>SWT.DEFER</code> flag always causes the layout to be deferred
* by calling <code>Composite.setLayoutDeferred(true)</code> and scheduling
* a call to <code>Composite.setLayoutDeferred(false)</code>, which will
* happen when appropriate (usually before the next event is handled). When
* this flag is set, the application should not call
* <code>Composite.setLayoutDeferred(boolean)</code>.
* </p>
* <p>
* Note: Layout is different from painting. If a child is moved or resized
* such that an area in the parent is exposed, then the parent will paint.
* If no child is affected, the parent will not paint.
* </p>
*
* @param changed
* a control that has had a state change which requires a
* recalculation of its size
* @param flags
* the flags specifying how the layout should happen
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if any of the controls in
* changed is null or has been disposed</li>
* <li>ERROR_INVALID_PARENT - if any control in changed is
* not in the widget tree of the receiver</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*
* @since 3.6
*/
public void layout(Control[] changed, int flags) {
// TODO
}
void removeControl (Control control) {
// TODO
}
/**
* Sets the background drawing mode to the argument which should be one of
* the following constants defined in class <code>SWT</code>:
* <code>INHERIT_NONE</code>, <code>INHERIT_DEFAULT</code>,
* <code>INHERIT_FORCE</code>.
*
* @param mode
* the new background mode
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*
* @see SWT
*
* @since 3.2
*/
public void setBackgroundMode(int mode) {
// TODO
}
/**
* Sets the layout which is associated with the receiver to be the argument
* which may be null.
*
* @param layout
* the receiver's new layout or null
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*/
public void setLayout(Layout layout) {
this.layout = layout;
}
/**
* If the argument is <code>true</code>, causes subsequent layout operations
* in the receiver or any of its children to be ignored. No layout of any
* kind can occur in the receiver or any of its children until the flag is
* set to false. Layout operations that occurred while the flag was
* <code>true</code> are remembered and when the flag is set to
* <code>false</code>, the layout operations are performed in an optimized
* manner. Nested calls to this method are stacked.
*
* @param defer
* the new defer state
*
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*
* @see #layout(boolean)
* @see #layout(Control[])
*
* @since 3.1
*/
public void setLayoutDeferred(boolean defer) {
// TODO
}
/**
* Sets the tabbing order for the specified controls to match the order that
* they occur in the argument list.
*
* @param tabList
* the ordered list of controls representing the tab order or
* null
*
* @exception IllegalArgumentException
* <ul>
* <li>ERROR_INVALID_ARGUMENT - if a widget in the tabList is
* null or has been disposed</li>
* <li>ERROR_INVALID_PARENT - if widget in the tabList is not
* in the same widget tree</li>
* </ul>
* @exception SWTException
* <ul>
* <li>ERROR_WIDGET_DISPOSED - if the receiver has been
* disposed</li>
* <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
* thread that created the receiver</li>
* </ul>
*/
public void setTabList(Control[] tabList) {
// TODO
}
}